package com.atguigu.tingshu.album.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.album.service.AuditService;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

import static com.atguigu.tingshu.common.constant.SystemConstant.*;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

	@Autowired
	private AlbumInfoMapper albumInfoMapper;
@Autowired
 private AlbumAttributeValueMapper albumAttributeValueMapper;

@Autowired
private AlbumStatMapper albumStatMapper;

@Autowired
private AuditService auditService;
@Autowired
private RabbitService rabbitService;

	//内容创作者或者平台运营人员-保存专辑
	@Override
	@Transactional(rollbackFor= Exception.class)
	public void saveAlbumInfo(AlbumInfoVo albumInfoVo, Long userId) {
		AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
        albumInfo.setUserId(userId);
		String payType = albumInfo.getPayType();
		if(ALBUM_PAY_TYPE_VIPFREE.equals(payType) || ALBUM_PAY_TYPE_REQUIRE.equals(payType)){
			albumInfo.setTracksForFree(3);
		}
		albumInfo.setStatus(ALBUM_STATUS_NO_PASS);
		albumInfoMapper.insert(albumInfo);
		Long albumId = albumInfo.getId();

		List<AlbumAttributeValue> albumAttributeValueVoList = albumInfo.getAlbumAttributeValueVoList();
		for (AlbumAttributeValue albumAttributeValueVo : albumAttributeValueVoList) {
			AlbumAttributeValue albumAttributeValue = BeanUtil.copyProperties(albumAttributeValueVo, AlbumAttributeValue.class);
			albumAttributeValue.setAlbumId(albumId);
			albumAttributeValueMapper.insert(albumAttributeValue);
		}
		this.saveAlbumInfoStat(albumId, ALBUM_STAT_PLAY, 0);
		this.saveAlbumInfoStat(albumId, ALBUM_STAT_SUBSCRIBE, 0);
		this.saveAlbumInfoStat(albumId, ALBUM_STAT_BUY, 0);
		this.saveAlbumInfoStat(albumId, ALBUM_STAT_COMMENT, 0);

		//ToDo  ES
		String text=albumInfo.getAlbumTitle()+albumInfo.getAlbumIntro();
		String suggestion = auditService.auditText(text);
		if("pass".equals(suggestion)){
			albumInfo.setStatus(ALBUM_STATUS_PASS);
			// 发送MQ消息通知搜素服务 将专辑存入ES库
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER,albumId);
		} else if ("review".equals(suggestion)) {
			albumInfo.setStatus(ALBUM_STATUS_REVIEW);
		} else if ("block".equals(suggestion)) {
			albumInfo.setStatus(ALBUM_STATUS_NO_PASS);
		}
		albumInfoMapper.updateById(albumInfo);
	}

	@Override
	public void saveAlbumInfoStat(Long albumId, String statType, int statNum) {
		AlbumStat albumStat = new AlbumStat();
		albumStat.setAlbumId(albumId);
		albumStat.setStatType(statType);
		albumStat.setStatNum(statNum);
		albumStatMapper.insert(albumStat);
	}

	@Override
	public Page<AlbumListVo> findUserAlbumPage(Page<AlbumListVo> pageParam, AlbumInfoQuery albumInfoQuery) {
		return albumInfoMapper.findUserAlbumPage(pageParam, albumInfoQuery);
	}



	@Autowired
	private TrackInfoMapper trackInfoMapper;
	//删除专辑(包括标签关系,统计数值)
	@Override
	@Transactional(rollbackFor = Exception.class)
	public void removeAlbumInfo(Long id, boolean b) {
     //查询专辑下面有没有音声
		Long count = trackInfoMapper.selectCount(new LambdaQueryWrapper<TrackInfo>()
				.eq(TrackInfo::getAlbumId, id));
		if(count>0){
			throw  new GuiguException(500,"有关联音声");
		}
		//根据Id删除专辑
		albumInfoMapper.deleteById(id);
		//根据逻辑外键(专辑的)删除专辑标签关系
		albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>()
				.eq(AlbumAttributeValue::getAlbumId,id));
		//根据逻辑外键删除专辑统计
		albumStatMapper.delete(new LambdaQueryWrapper<AlbumStat>()
				.eq(AlbumStat::getAlbumId,id));

		//基于MQ删除存在Elasticsearch(全文搜索引擎)中的数据
		rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);
	}

	@Override
	public AlbumInfo getAlbumInfo(Long id) {
		AlbumInfo albumInfo = albumInfoMapper.selectById(id);
		if(albumInfo !=null){
			List<AlbumAttributeValue> albumAttributeValues = albumAttributeValueMapper.selectList(new LambdaQueryWrapper<AlbumAttributeValue>()
					.eq(AlbumAttributeValue::getAlbumId,id));
			albumInfo.setAlbumAttributeValueVoList(albumAttributeValues);
		}
		return albumInfo;
	}


	//更新专辑
	@Transactional(rollbackFor = Exception.class)
	@Override
	public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
		AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
		albumInfo.setId(id);
		albumInfo.setStatus(ALBUM_STATUS_NO_PASS);
       albumInfoMapper.updateById(albumInfo);

	   albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>()
			   .eq(AlbumAttributeValue::getAlbumId,id));

		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo
				.getAlbumAttributeValueVoList();
		if(CollUtil.isNotEmpty(albumAttributeValueVoList)){
			for (AlbumAttributeValueVo albumAttributeValueVo : albumAttributeValueVoList) {
				AlbumAttributeValue albumAttributeValue = BeanUtil
						.copyProperties(albumAttributeValueVo, AlbumAttributeValue.class);
				albumAttributeValue.setAlbumId(id);
				albumAttributeValueMapper.insert(albumAttributeValue);
			}
		}

		String text=albumInfo.getAlbumTitle()+albumInfo.getAlbumIntro();
		String suggestion = auditService.auditText(text);
		if("pass".equals(suggestion)){
			albumInfo.setStatus(ALBUM_STATUS_PASS);
			// 发送MQ消息通知搜素服务 将专辑存入ES库
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER,id);
		} else if ("review".equals(suggestion)) {
			// 发送MQ消息通知搜素服务 从ES库删除
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);
			albumInfo.setStatus(ALBUM_STATUS_REVIEW);
		} else if ("block".equals(suggestion)) {
			// 发送MQ消息通知搜素服务 从ES库删除
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);
			albumInfo.setStatus(ALBUM_STATUS_NO_PASS);
		}
		albumInfoMapper.updateById(albumInfo);
	}

	@Override
	public List<AlbumInfo> findUserAllAlbumList(Long userId) {
		//设置条件查询专辑ID及专辑名称,当前用户,状态审核通过及查询条数200并根据ID降序排序
		LambdaQueryWrapper<AlbumInfo> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.select(AlbumInfo::getId,AlbumInfo::getAlbumTitle);
		queryWrapper.last("limit 200");
		queryWrapper.eq(AlbumInfo::getUserId,userId).eq(AlbumInfo::getStatus, ALBUM_STATUS_PASS);
		queryWrapper.orderByDesc(AlbumInfo::getId);
      //获取专辑列表
	 return albumInfoMapper.selectList(queryWrapper);
	}

	////根据专辑ID查询专辑统计数值
	@Override
	public AlbumStatVo getAlbumStatVo(Long albumId) {
		return albumInfoMapper.getAlbumStatVo(albumId);
	}
}
